Software may be developed using different target CPU architectures. For example, a large enterprise that develops software products may have an extensive number of computing systems for developing and debugging software source code. The computing systems may each have a different CPU architecture, such as systems having an X86 processor and systems having an IA-64 “Itanium” processor. A software developer may use the X86 system to design and debug the source code, but may also use the IA-64 system while designing and debugging the source code, or vice versa. In another example, while at work, a software developer may use a computing system to design and debug source code. However, a software developer may also work using a home system which may have a different CPU architecture from the software developer's work system. For instance, the software developer may use a gaming system at home to design and debug the source code.
While debugging the source code, software developers expect that the behavior of the source code and the behavior of the debugging tool remain consistent across the different target CPU architectures. However, the various CPU architectures may process the same source code differently. For example, a user may initiate a debugging finish command to have a specified source code function continue execution and stop exactly at the moment the specified function has exited and returned to its caller function. After initiating a finish command, a user may expect to see an indicator in a debugging graphical user interface (GUI) at the line of source code that corresponds to the executed function call source line at the caller function. A user may debug source code using an IA-64 system, initiate a debugging finish command, and see an indicator in the debugging GUI at the executed function call source line at the caller function as expected. The user, however, may debug the same source code using an X86 system. After initiating a finish command, the user may not see an indicator in the debugging GUI at the executed function call source line at the caller function, but rather, at the next source line instead. This inconsistency in the behavior of debugging the same source code on various target CPU architecture can create an inadequate and inefficient software development environment.